﻿#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLuaBase.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class MarchEntityWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(MarchEntity);
			Utils.BeginObjectRegister(type, L, translator, 0, 110, 27, 18);
			
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Initialize", _m_Initialize);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddForwardObj", _m_AddForwardObj);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveForwardObj", _m_RemoveForwardObj);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGameObject", _m_GetGameObject);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAudioEmiterObject", _m_GetAudioEmiterObject);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMarchType", _m_GetMarchType);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTeam", _m_SetTeam);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDrawLineColor", _m_SetDrawLineColor);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTouchable", _m_SetTouchable);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateBasicInfoMonster", _m_UpdateBasicInfoMonster);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateBasicInfoDefence", _m_UpdateBasicInfoDefence);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateEscapeInfo", _m_UpdateEscapeInfo);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartCrossingGate", _m_StartCrossingGate);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "EndCrossingGate", _m_EndCrossingGate);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMarchDataToSquareData", _m_SetMarchDataToSquareData);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTargetId", _m_SetTargetId);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopMarch", _m_StopMarch);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateRadius", _m_UpdateRadius);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckNeedResetChildrenNum", _m_CheckNeedResetChildrenNum);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckNeedResetMarchSkin", _m_CheckNeedResetMarchSkin);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsSpriteSquare", _m_IsSpriteSquare);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsNotShowModel", _m_IsNotShowModel);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "DisposeHud", _m_DisposeHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsHudShown", _m_IsHudShown);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "HideHud", _m_HideHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetHeroIcon", _m_SetHeroIcon);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowCargoTruckHud", _m_ShowCargoTruckHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowMarchHud", _m_ShowMarchHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowPractiseBossHud", _m_ShowPractiseBossHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowWorldBossHud", _m_ShowWorldBossHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowMonsterHud", _m_ShowMonsterHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowSmugglerHud", _m_ShowSmugglerHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearChasingTroopState", _m_ClearChasingTroopState);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayDeathAndRunAwayEffect", _m_PlayDeathAndRunAwayEffect);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayDeathOnlyHideEffect", _m_PlayDeathOnlyHideEffect);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayBossDead", _m_PlayBossDead);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayBossVanish", _m_PlayBossVanish);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayMonsterGotoBuilding", _m_PlayMonsterGotoBuilding);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowTsanTip", _m_ShowTsanTip);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveTsanTip", _m_RemoveTsanTip);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetLastRage", _m_ResetLastRage);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRoundFightOver", _m_SetRoundFightOver);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMarchStatus", _m_SetMarchStatus);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetForward", _m_SetForward);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsMoving", _m_IsMoving);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTarget", _m_GetTarget);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAttack", _m_RemoveAttack);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRandomSoldierPosition", _m_GetRandomSoldierPosition);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSelected", _m_SetSelected);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpateModelTotalNumBySoldierCount", _m_UpateModelTotalNumBySoldierCount);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "FakeKnockBack", _m_FakeKnockBack);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "FakeMoveForward", _m_FakeMoveForward);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "EndFakeMoveForward", _m_EndFakeMoveForward);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReadyToHide", _m_ReadyToHide);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopReadyToHide", _m_StopReadyToHide);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateHudHpPercent", _m_UpdateHudHpPercent);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShakeHud", _m_ShakeHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetFormation", _m_ResetFormation);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMarchDefaultForward", _m_SetMarchDefaultForward);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMarchDefaultForward", _m_GetMarchDefaultForward);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckNeedGenerateChasePathList", _m_CheckNeedGenerateChasePathList);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckNeedGenerateChasePathListAndRefresh", _m_CheckNeedGenerateChasePathListAndRefresh);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForceSetPosition", _m_ForceSetPosition);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowDebug", _m_ShowDebug);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForceShowCommanderHead", _m_ForceShowCommanderHead);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ManualUpdateSelectedHud", _m_ManualUpdateSelectedHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ManualUpdateBattleHud", _m_ManualUpdateBattleHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsReadyToRemove", _m_IsReadyToRemove);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckIsSelfMarch", _m_CheckIsSelfMarch);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNickName", _m_SetNickName);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNickNameWithColor", _m_SetNickNameWithColor);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRenownName", _m_SetRenownName);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetKillTip", _m_SetKillTip);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIsFakeParent", _m_SetIsFakeParent);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFakeChildEntities", _m_GetFakeChildEntities);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddFakeChild", _m_AddFakeChild);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlaySkillAnimation", _m_PlaySkillAnimation);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAttackAnimationSpeed", _m_SetAttackAnimationSpeed);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateMonsterColliderEnabled", _m_UpdateMonsterColliderEnabled);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnHeroChanged", _m_OnHeroChanged);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckRtsServerInfoChanged", _m_CheckRtsServerInfoChanged);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateRageHerIdx", _m_UpdateRageHerIdx);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "DisposeSkillOutSide", _m_DisposeSkillOutSide);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCarSkill", _m_GetCarSkill);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCarSkill", _m_SetCarSkill);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMonsterRadius", _m_SetMonsterRadius);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMarchHudLod1ExtraOffset", _m_SetMarchHudLod1ExtraOffset);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPlayerTitle", _m_SetPlayerTitle);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SmuggleEntityUpdate", _m_SmuggleEntityUpdate);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "FadeIn", _m_FadeIn);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "FadeOut", _m_FadeOut);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelayRemoveTime", _m_SetDelayRemoveTime);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTruckCrushTime", _m_SetTruckCrushTime);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIsTruckFighting", _m_SetIsTruckFighting);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIsTrainFighting", _m_SetIsTrainFighting);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIsCanShowNewYearHud", _m_SetIsCanShowNewYearHud);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNewYearHudVisible", _m_SetNewYearHudVisible);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNewYearHudArgus", _m_SetNewYearHudArgus);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNewYearHudIconPath", _m_SetNewYearHudIconPath);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartPlayTruckAttacking", _m_StartPlayTruckAttacking);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsTruckAttacking", _m_IsTruckAttacking);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTruckAttackerPosition", _m_GetTruckAttackerPosition);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTruckAttackerForward", _m_GetTruckAttackerForward);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartPlayTrainDefending", _m_StartPlayTrainDefending);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIsPveBattleWin", _m_SetIsPveBattleWin);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "isTruckAttackerMarch", _m_isTruckAttackerMarch);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "isTrainAttackerMarch", _m_isTrainAttackerMarch);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "isTrainDefenceMarch", _m_isTrainDefenceMarch);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "isClientCreateMarch", _m_isClientCreateMarch);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "isTroopWorldRight", _m_isTroopWorldRight);
			
			
			Utils.RegisterFunc(L, Utils.GETTER_IDX, "formationCfgs", _g_get_formationCfgs);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsInBattle", _g_get_IsInBattle);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Tid", _g_get_Tid);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Forward", _g_get_Forward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Position", _g_get_Position);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "EndPosition", _g_get_EndPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "AttackForward", _g_get_AttackForward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Team", _g_get_Team);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "formationPos", _g_get_formationPos);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "squareDataIndex", _g_get_squareDataIndex);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "flyTextTimeOffset", _g_get_flyTextTimeOffset);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isMonster", _g_get_isMonster);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "LineId", _g_get_LineId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "RtsServerInfo", _g_get_RtsServerInfo);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "MarchManager", _g_get_MarchManager);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isMonsterBattleSoundDirty", _g_get_isMonsterBattleSoundDirty);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "fixedSoldierID", _g_get_fixedSoldierID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "forwardObjList", _g_get_forwardObjList);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Visible", _g_get_Visible);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "InitPos", _g_get_InitPos);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isFakeParent", _g_get_isFakeParent);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isFakeChild", _g_get_isFakeChild);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "childEntities", _g_get_childEntities);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "TargetCoordinateType", _g_get_TargetCoordinateType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isMarchVisibleInLod", _g_get_isMarchVisibleInLod);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "defaultForward", _g_get_defaultForward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPveBattleWin", _g_get_isPveBattleWin);
            
			Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsInBattle", _s_set_IsInBattle);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "flyTextTimeOffset", _s_set_flyTextTimeOffset);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isMonster", _s_set_isMonster);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "LineId", _s_set_LineId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "RtsServerInfo", _s_set_RtsServerInfo);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "MarchManager", _s_set_MarchManager);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isMonsterBattleSoundDirty", _s_set_isMonsterBattleSoundDirty);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "fixedSoldierID", _s_set_fixedSoldierID);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "forwardObjList", _s_set_forwardObjList);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "Visible", _s_set_Visible);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "InitPos", _s_set_InitPos);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isFakeParent", _s_set_isFakeParent);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isFakeChild", _s_set_isFakeChild);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "childEntities", _s_set_childEntities);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "TargetCoordinateType", _s_set_TargetCoordinateType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isMarchVisibleInLod", _s_set_isMarchVisibleInLod);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "defaultForward", _s_set_defaultForward);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isPveBattleWin", _s_set_isPveBattleWin);
            
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
			
			
            
			
			
			
            Utils.RegisterFunc(L, Utils.CLS_IDX, "New", __CreateInstanceNew);
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 1)
				{
					
					var gen_ret = new MarchEntity();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to MarchEntity constructor!");
            
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstanceNew(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 0)
				{
					
					var gen_ret = new MarchEntity();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to MarchEntity constructor!");
            
        }

        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Initialize(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    long _tid = LuaAPI.lua_toint64(L, 2);
                    int _team = LuaAPI.xlua_tointeger(L, 3);
                    Yoozoo.Gameplay.RTS.EClientMarchType _clientMarchType;translator.Get(L, 4, out _clientMarchType);
                    Yoozoo.Gameplay.RTS.Proto.TargetCoordinateType _targetCoordinateType;translator.Get(L, 5, out _targetCoordinateType);
                    
                    gen_to_be_invoked.Initialize( _tid, _team, _clientMarchType, _targetCoordinateType );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddForwardObj(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    UnityEngine.Transform _trans = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform));
                    
                    gen_to_be_invoked.AddForwardObj( _trans );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveForwardObj(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    UnityEngine.Transform _trans = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform));
                    
                    gen_to_be_invoked.RemoveForwardObj( _trans );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetGameObject(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetGameObject(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetAudioEmiterObject(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetAudioEmiterObject(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMarchType(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetMarchType(  );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetTeam(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _team = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.SetTeam( _team );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetDrawLineColor(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.SetDrawLineColor(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetTouchable(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _value = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetTouchable( _value );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateBasicInfoMonster(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    XLua.LuaTable _heroList = (XLua.LuaTable)translator.GetObject(L, 2, typeof(XLua.LuaTable));
                    UnityEngine.Vector3 _position;translator.Get(L, 3, out _position);
                    
                    gen_to_be_invoked.UpdateBasicInfoMonster( _heroList, _position );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateBasicInfoDefence(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    XLua.LuaTable _heroList = (XLua.LuaTable)translator.GetObject(L, 2, typeof(XLua.LuaTable));
                    UnityEngine.Vector3 _position;translator.Get(L, 3, out _position);
                    
                    gen_to_be_invoked.UpdateBasicInfoDefence( _heroList, _position );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateEscapeInfo(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.UpdateEscapeInfo(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StartCrossingGate(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    bool _needShowTransition = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.StartCrossingGate( _needShowTransition );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1) 
                {
                    
                    gen_to_be_invoked.StartCrossingGate(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to MarchEntity.StartCrossingGate!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_EndCrossingGate(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.EndCrossingGate(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMarchDataToSquareData(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.SetMarchDataToSquareData(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetTargetId(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    long _targetId = LuaAPI.lua_toint64(L, 2);
                    
                    gen_to_be_invoked.SetTargetId( _targetId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StopMarch(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) 
                {
                    UnityEngine.Vector3 _position;translator.Get(L, 2, out _position);
                    bool _forceRefresh = LuaAPI.lua_toboolean(L, 3);
                    
                    gen_to_be_invoked.StopMarch( _position, _forceRefresh );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Vector3>(L, 2)) 
                {
                    UnityEngine.Vector3 _position;translator.Get(L, 2, out _position);
                    
                    gen_to_be_invoked.StopMarch( _position );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to MarchEntity.StopMarch!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateRadius(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    float _radius = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    gen_to_be_invoked.UpdateRadius( _radius );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckNeedResetChildrenNum(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _soldierCount = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.CheckNeedResetChildrenNum( _soldierCount );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckNeedResetMarchSkin(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _marchResId = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.CheckNeedResetMarchSkin( _marchResId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsSpriteSquare(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsSpriteSquare(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsNotShowModel(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsNotShowModel(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_DisposeHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.DisposeHud(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsHudShown(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsHudShown(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HideHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.HideHud(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetHeroIcon(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    com.yoozoo.gta.Gameplay.RTS.RtsServerInfo _serverInfo = (com.yoozoo.gta.Gameplay.RTS.RtsServerInfo)translator.GetObject(L, 2, typeof(com.yoozoo.gta.Gameplay.RTS.RtsServerInfo));
                    
                    gen_to_be_invoked.SetHeroIcon( _serverInfo );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowCargoTruckHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    com.yoozoo.gta.Gameplay.RTS.RtsServerInfo _serverInfo = (com.yoozoo.gta.Gameplay.RTS.RtsServerInfo)translator.GetObject(L, 2, typeof(com.yoozoo.gta.Gameplay.RTS.RtsServerInfo));
                    Yoozoo.Gameplay.RTS.MarchContext _marchContext = (Yoozoo.Gameplay.RTS.MarchContext)translator.GetObject(L, 3, typeof(Yoozoo.Gameplay.RTS.MarchContext));
                    
                    gen_to_be_invoked.ShowCargoTruckHud( _serverInfo, _marchContext );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowMarchHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    com.yoozoo.gta.Gameplay.RTS.RtsServerInfo _serverInfo = (com.yoozoo.gta.Gameplay.RTS.RtsServerInfo)translator.GetObject(L, 2, typeof(com.yoozoo.gta.Gameplay.RTS.RtsServerInfo));
                    Yoozoo.Gameplay.RTS.MarchContext _marchContext = (Yoozoo.Gameplay.RTS.MarchContext)translator.GetObject(L, 3, typeof(Yoozoo.Gameplay.RTS.MarchContext));
                    
                    gen_to_be_invoked.ShowMarchHud( _serverInfo, _marchContext );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowPractiseBossHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    com.yoozoo.gta.Gameplay.RTS.RtsServerInfo _serverInfo = (com.yoozoo.gta.Gameplay.RTS.RtsServerInfo)translator.GetObject(L, 2, typeof(com.yoozoo.gta.Gameplay.RTS.RtsServerInfo));
                    Yoozoo.Gameplay.RTS.MarchContext _marchContext = (Yoozoo.Gameplay.RTS.MarchContext)translator.GetObject(L, 3, typeof(Yoozoo.Gameplay.RTS.MarchContext));
                    
                    gen_to_be_invoked.ShowPractiseBossHud( _serverInfo, _marchContext );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowWorldBossHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    com.yoozoo.gta.Gameplay.RTS.RtsServerInfo _serverInfo = (com.yoozoo.gta.Gameplay.RTS.RtsServerInfo)translator.GetObject(L, 2, typeof(com.yoozoo.gta.Gameplay.RTS.RtsServerInfo));
                    Yoozoo.Gameplay.RTS.MarchContext _marchContext = (Yoozoo.Gameplay.RTS.MarchContext)translator.GetObject(L, 3, typeof(Yoozoo.Gameplay.RTS.MarchContext));
                    
                    gen_to_be_invoked.ShowWorldBossHud( _serverInfo, _marchContext );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowMonsterHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    com.yoozoo.gta.Gameplay.RTS.RtsServerInfo _serverInfo = (com.yoozoo.gta.Gameplay.RTS.RtsServerInfo)translator.GetObject(L, 2, typeof(com.yoozoo.gta.Gameplay.RTS.RtsServerInfo));
                    Yoozoo.Gameplay.RTS.MarchContext _marchContext = (Yoozoo.Gameplay.RTS.MarchContext)translator.GetObject(L, 3, typeof(Yoozoo.Gameplay.RTS.MarchContext));
                    
                    gen_to_be_invoked.ShowMonsterHud( _serverInfo, _marchContext );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowSmugglerHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    com.yoozoo.gta.Gameplay.RTS.RtsServerInfo _serverInfo = (com.yoozoo.gta.Gameplay.RTS.RtsServerInfo)translator.GetObject(L, 2, typeof(com.yoozoo.gta.Gameplay.RTS.RtsServerInfo));
                    Yoozoo.Gameplay.RTS.MarchContext _marchContext = (Yoozoo.Gameplay.RTS.MarchContext)translator.GetObject(L, 3, typeof(Yoozoo.Gameplay.RTS.MarchContext));
                    
                    gen_to_be_invoked.ShowSmugglerHud( _serverInfo, _marchContext );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ClearChasingTroopState(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string _targetId = LuaAPI.lua_tostring(L, 2);
                    
                    gen_to_be_invoked.ClearChasingTroopState( _targetId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayDeathAndRunAwayEffect(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.PlayDeathAndRunAwayEffect(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayDeathOnlyHideEffect(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.PlayDeathOnlyHideEffect(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayBossDead(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.PlayBossDead(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayBossVanish(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.PlayBossVanish(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayMonsterGotoBuilding(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.PlayMonsterGotoBuilding(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowTsanTip(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _isWebHead = LuaAPI.lua_toboolean(L, 2);
                    string _headPath = LuaAPI.lua_tostring(L, 3);
                    string _framePath = LuaAPI.lua_tostring(L, 4);
                    string _desc = LuaAPI.lua_tostring(L, 5);
                    
                    gen_to_be_invoked.ShowTsanTip( _isWebHead, _headPath, _framePath, _desc );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveTsanTip(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.RemoveTsanTip(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ResetLastRage(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ResetLastRage(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetRoundFightOver(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.SetRoundFightOver(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMarchStatus(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Yoozoo.Gameplay.RTS.EMarchStatus _marchstatus;translator.Get(L, 2, out _marchstatus);
                    
                    gen_to_be_invoked.SetMarchStatus( _marchstatus );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetForward(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    UnityEngine.Vector3 _forward;translator.Get(L, 2, out _forward);
                    
                    gen_to_be_invoked.SetForward( _forward );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsMoving(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsMoving(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTarget(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetTarget(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveAttack(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.RemoveAttack(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetRandomSoldierPosition(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetRandomSoldierPosition(  );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetSelected(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 4&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) 
                {
                    bool _value = LuaAPI.lua_toboolean(L, 2);
                    bool _isClickSelected = LuaAPI.lua_toboolean(L, 3);
                    bool _isMultySelect = LuaAPI.lua_toboolean(L, 4);
                    
                    gen_to_be_invoked.SetSelected( _value, _isClickSelected, _isMultySelect );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) 
                {
                    bool _value = LuaAPI.lua_toboolean(L, 2);
                    bool _isClickSelected = LuaAPI.lua_toboolean(L, 3);
                    
                    gen_to_be_invoked.SetSelected( _value, _isClickSelected );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    bool _value = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetSelected( _value );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to MarchEntity.SetSelected!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpateModelTotalNumBySoldierCount(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _squareSoldierCount = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = gen_to_be_invoked.UpateModelTotalNumBySoldierCount( _squareSoldierCount );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_FakeKnockBack(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 4&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) 
                {
                    UnityEngine.Vector3 _forward;translator.Get(L, 2, out _forward);
                    int _count = LuaAPI.xlua_tointeger(L, 3);
                    int _externalSoldierId = LuaAPI.xlua_tointeger(L, 4);
                    
                    gen_to_be_invoked.FakeKnockBack( _forward, _count, _externalSoldierId );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 3&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    UnityEngine.Vector3 _forward;translator.Get(L, 2, out _forward);
                    int _count = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.FakeKnockBack( _forward, _count );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to MarchEntity.FakeKnockBack!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_FakeMoveForward(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 4&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Vector3>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) 
                {
                    UnityEngine.Vector3 _startPosition;translator.Get(L, 2, out _startPosition);
                    UnityEngine.Vector3 _targetPosition;translator.Get(L, 3, out _targetPosition);
                    float _speed = (float)LuaAPI.lua_tonumber(L, 4);
                    
                    gen_to_be_invoked.FakeMoveForward( _startPosition, _targetPosition, _speed );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 3&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Vector3>(L, 3)) 
                {
                    UnityEngine.Vector3 _startPosition;translator.Get(L, 2, out _startPosition);
                    UnityEngine.Vector3 _targetPosition;translator.Get(L, 3, out _targetPosition);
                    
                    gen_to_be_invoked.FakeMoveForward( _startPosition, _targetPosition );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to MarchEntity.FakeMoveForward!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_EndFakeMoveForward(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.EndFakeMoveForward(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ReadyToHide(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ReadyToHide(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StopReadyToHide(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.StopReadyToHide(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateHudHpPercent(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.UpdateHudHpPercent(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShakeHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ShakeHud(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ResetFormation(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ResetFormation(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMarchDefaultForward(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    UnityEngine.Vector3 _forward;translator.Get(L, 2, out _forward);
                    
                    gen_to_be_invoked.SetMarchDefaultForward( _forward );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMarchDefaultForward(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    long _tid = LuaAPI.lua_toint64(L, 2);
                    
                        var gen_ret = gen_to_be_invoked.GetMarchDefaultForward( _tid );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckNeedGenerateChasePathList(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    MarchEntity _target = (MarchEntity)translator.GetObject(L, 2, typeof(MarchEntity));
                    com.yoozoo.gta.Gameplay.RTS.RtsServerInfo _serverData = (com.yoozoo.gta.Gameplay.RTS.RtsServerInfo)translator.GetObject(L, 3, typeof(com.yoozoo.gta.Gameplay.RTS.RtsServerInfo));
                    
                    gen_to_be_invoked.CheckNeedGenerateChasePathList( _target, _serverData );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckNeedGenerateChasePathListAndRefresh(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    MarchEntity _target = (MarchEntity)translator.GetObject(L, 2, typeof(MarchEntity));
                    
                    gen_to_be_invoked.CheckNeedGenerateChasePathListAndRefresh( _target );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ForceSetPosition(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    UnityEngine.Vector3 _position;translator.Get(L, 2, out _position);
                    
                    gen_to_be_invoked.ForceSetPosition( _position );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowDebug(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ShowDebug(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ForceShowCommanderHead(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _isShow = LuaAPI.lua_toboolean(L, 2);
                    bool _isBattleStyle = LuaAPI.lua_toboolean(L, 3);
                    
                    gen_to_be_invoked.ForceShowCommanderHead( _isShow, _isBattleStyle );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ManualUpdateSelectedHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ManualUpdateSelectedHud(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ManualUpdateBattleHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ManualUpdateBattleHud(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsReadyToRemove(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsReadyToRemove(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckIsSelfMarch(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.CheckIsSelfMarch(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetNickName(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string _nickName = LuaAPI.lua_tostring(L, 2);
                    
                    gen_to_be_invoked.SetNickName( _nickName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetNickNameWithColor(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string _nickName = LuaAPI.lua_tostring(L, 2);
                    bool _usOrEnemy = LuaAPI.lua_toboolean(L, 3);
                    
                    gen_to_be_invoked.SetNickNameWithColor( _nickName, _usOrEnemy );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetRenownName(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string _renownName = LuaAPI.lua_tostring(L, 2);
                    int _quality = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.SetRenownName( _renownName, _quality );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetKillTip(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _killNum = LuaAPI.xlua_tointeger(L, 2);
                    string _killTip = LuaAPI.lua_tostring(L, 3);
                    
                    gen_to_be_invoked.SetKillTip( _killNum, _killTip );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsFakeParent(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.SetIsFakeParent(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetFakeChildEntities(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetFakeChildEntities(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddFakeChild(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    MarchEntity _child = (MarchEntity)translator.GetObject(L, 2, typeof(MarchEntity));
                    
                    gen_to_be_invoked.AddFakeChild( _child );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlaySkillAnimation(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string _animation = LuaAPI.lua_tostring(L, 2);
                    
                    gen_to_be_invoked.PlaySkillAnimation( _animation );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetAttackAnimationSpeed(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    float _animationSpeed = (float)LuaAPI.lua_tonumber(L, 2);
                    float _speedTime = (float)LuaAPI.lua_tonumber(L, 3);
                    
                    gen_to_be_invoked.SetAttackAnimationSpeed( _animationSpeed, _speedTime );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateMonsterColliderEnabled(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _lodLevel = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.UpdateMonsterColliderEnabled( _lodLevel );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnHeroChanged(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.OnHeroChanged(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckRtsServerInfoChanged(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.CheckRtsServerInfoChanged(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateRageHerIdx(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _heroIdx = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.UpdateRageHerIdx( _heroIdx );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_DisposeSkillOutSide(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.DisposeSkillOutSide(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetCarSkill(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetCarSkill(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetCarSkill(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Yoozoo.Gameplay.RTS.SkillHit _skillHit = (Yoozoo.Gameplay.RTS.SkillHit)translator.GetObject(L, 2, typeof(Yoozoo.Gameplay.RTS.SkillHit));
                    
                    gen_to_be_invoked.SetCarSkill( _skillHit );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMonsterRadius(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _monsterType = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.SetMonsterRadius( _monsterType );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMarchHudLod1ExtraOffset(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    float _extraOffset = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    gen_to_be_invoked.SetMarchHudLod1ExtraOffset( _extraOffset );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetPlayerTitle(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.SetPlayerTitle(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SmuggleEntityUpdate(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.SmuggleEntityUpdate(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_FadeIn(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    float _time = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    gen_to_be_invoked.FadeIn( _time );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_FadeOut(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    float _time = (float)LuaAPI.lua_tonumber(L, 2);
                    float _delayTime = (float)LuaAPI.lua_tonumber(L, 3);
                    
                    gen_to_be_invoked.FadeOut( _time, _delayTime );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                {
                    float _time = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    gen_to_be_invoked.FadeOut( _time );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to MarchEntity.FadeOut!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetDelayRemoveTime(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    float _time = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    gen_to_be_invoked.SetDelayRemoveTime( _time );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetTruckCrushTime(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    float _time = (float)LuaAPI.lua_tonumber(L, 2);
                    float _duration = (float)LuaAPI.lua_tonumber(L, 3);
                    UnityEngine.Vector3 _crushDirection;translator.Get(L, 4, out _crushDirection);
                    
                    gen_to_be_invoked.SetTruckCrushTime( _time, _duration, _crushDirection );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsTruckFighting(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _isFighting = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetIsTruckFighting( _isFighting );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsTrainFighting(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _isFighting = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetIsTrainFighting( _isFighting );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsCanShowNewYearHud(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _value = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetIsCanShowNewYearHud( _value );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetNewYearHudVisible(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _value = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetNewYearHudVisible( _value );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetNewYearHudArgus(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    float _cdTime = (float)LuaAPI.lua_tonumber(L, 2);
                    string _iconPath = LuaAPI.lua_tostring(L, 3);
                    XLua.LuaFunction _luaCallback = (XLua.LuaFunction)translator.GetObject(L, 4, typeof(XLua.LuaFunction));
                    
                    gen_to_be_invoked.SetNewYearHudArgus( _cdTime, _iconPath, _luaCallback );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetNewYearHudIconPath(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string _iconPath = LuaAPI.lua_tostring(L, 2);
                    
                    gen_to_be_invoked.SetNewYearHudIconPath( _iconPath );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StartPlayTruckAttacking(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 7&& translator.Assignable<MarchEntity>(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) 
                {
                    MarchEntity _targetTruck = (MarchEntity)translator.GetObject(L, 2, typeof(MarchEntity));
                    bool _isAttackerWin = LuaAPI.lua_toboolean(L, 3);
                    bool _isWin = LuaAPI.lua_toboolean(L, 4);
                    int _battleIdx = LuaAPI.xlua_tointeger(L, 5);
                    string _res = LuaAPI.lua_tostring(L, 6);
                    float _delayTime = (float)LuaAPI.lua_tonumber(L, 7);
                    
                    gen_to_be_invoked.StartPlayTruckAttacking( _targetTruck, _isAttackerWin, _isWin, _battleIdx, _res, _delayTime );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 6&& translator.Assignable<MarchEntity>(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)) 
                {
                    MarchEntity _targetTruck = (MarchEntity)translator.GetObject(L, 2, typeof(MarchEntity));
                    bool _isAttackerWin = LuaAPI.lua_toboolean(L, 3);
                    bool _isWin = LuaAPI.lua_toboolean(L, 4);
                    int _battleIdx = LuaAPI.xlua_tointeger(L, 5);
                    string _res = LuaAPI.lua_tostring(L, 6);
                    
                    gen_to_be_invoked.StartPlayTruckAttacking( _targetTruck, _isAttackerWin, _isWin, _battleIdx, _res );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 5&& translator.Assignable<MarchEntity>(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) 
                {
                    MarchEntity _targetTruck = (MarchEntity)translator.GetObject(L, 2, typeof(MarchEntity));
                    bool _isAttackerWin = LuaAPI.lua_toboolean(L, 3);
                    bool _isWin = LuaAPI.lua_toboolean(L, 4);
                    int _battleIdx = LuaAPI.xlua_tointeger(L, 5);
                    
                    gen_to_be_invoked.StartPlayTruckAttacking( _targetTruck, _isAttackerWin, _isWin, _battleIdx );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 4&& translator.Assignable<MarchEntity>(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) 
                {
                    MarchEntity _targetTruck = (MarchEntity)translator.GetObject(L, 2, typeof(MarchEntity));
                    bool _isAttackerWin = LuaAPI.lua_toboolean(L, 3);
                    bool _isWin = LuaAPI.lua_toboolean(L, 4);
                    
                    gen_to_be_invoked.StartPlayTruckAttacking( _targetTruck, _isAttackerWin, _isWin );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to MarchEntity.StartPlayTruckAttacking!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsTruckAttacking(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsTruckAttacking(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTruckAttackerPosition(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetTruckAttackerPosition(  );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTruckAttackerForward(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetTruckAttackerForward(  );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StartPlayTrainDefending(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 5&& translator.Assignable<MarchEntity>(L, 2)&& translator.Assignable<MarchEntity>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) 
                {
                    MarchEntity _defence = (MarchEntity)translator.GetObject(L, 2, typeof(MarchEntity));
                    MarchEntity _train = (MarchEntity)translator.GetObject(L, 3, typeof(MarchEntity));
                    int _battleIdx = LuaAPI.xlua_tointeger(L, 4);
                    float _delayTime = (float)LuaAPI.lua_tonumber(L, 5);
                    
                    gen_to_be_invoked.StartPlayTrainDefending( _defence, _train, _battleIdx, _delayTime );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 4&& translator.Assignable<MarchEntity>(L, 2)&& translator.Assignable<MarchEntity>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) 
                {
                    MarchEntity _defence = (MarchEntity)translator.GetObject(L, 2, typeof(MarchEntity));
                    MarchEntity _train = (MarchEntity)translator.GetObject(L, 3, typeof(MarchEntity));
                    int _battleIdx = LuaAPI.xlua_tointeger(L, 4);
                    
                    gen_to_be_invoked.StartPlayTrainDefending( _defence, _train, _battleIdx );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to MarchEntity.StartPlayTrainDefending!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsPveBattleWin(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _isPveBattleWin = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetIsPveBattleWin( _isPveBattleWin );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_isTruckAttackerMarch(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.isTruckAttackerMarch(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_isTrainAttackerMarch(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.isTrainAttackerMarch(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_isTrainDefenceMarch(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.isTrainDefenceMarch(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_isClientCreateMarch(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.isClientCreateMarch(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_isTroopWorldRight(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.isTroopWorldRight(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_formationCfgs(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.formationCfgs);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsInBattle(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsInBattle);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Tid(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushint64(L, gen_to_be_invoked.Tid);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Forward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.Forward);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Position(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.Position);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_EndPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.EndPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_AttackForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.AttackForward);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Team(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Team);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_formationPos(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.formationPos);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_squareDataIndex(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.squareDataIndex);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_flyTextTimeOffset(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flyTextTimeOffset);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isMonster(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isMonster);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_LineId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.LineId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_RtsServerInfo(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.RtsServerInfo);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MarchManager(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.MarchManager);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isMonsterBattleSoundDirty(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isMonsterBattleSoundDirty);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_fixedSoldierID(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.fixedSoldierID);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_forwardObjList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.forwardObjList);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Visible(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Visible);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_InitPos(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.InitPos);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isFakeParent(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isFakeParent);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isFakeChild(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isFakeChild);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_childEntities(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.childEntities);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_TargetCoordinateType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.TargetCoordinateType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isMarchVisibleInLod(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isMarchVisibleInLod);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_defaultForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.defaultForward);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isPveBattleWin(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPveBattleWin);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsInBattle(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.IsInBattle = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_flyTextTimeOffset(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.flyTextTimeOffset = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isMonster(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isMonster = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_LineId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.LineId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_RtsServerInfo(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.RtsServerInfo = (com.yoozoo.gta.Gameplay.RTS.RtsServerInfo)translator.GetObject(L, 2, typeof(com.yoozoo.gta.Gameplay.RTS.RtsServerInfo));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_MarchManager(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.MarchManager = (Yoozoo.Gameplay.RTS.MarchManager)translator.GetObject(L, 2, typeof(Yoozoo.Gameplay.RTS.MarchManager));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isMonsterBattleSoundDirty(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isMonsterBattleSoundDirty = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_fixedSoldierID(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.fixedSoldierID = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_forwardObjList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.forwardObjList = (System.Collections.Generic.List<UnityEngine.Transform>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<UnityEngine.Transform>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_Visible(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.Visible = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_InitPos(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.InitPos = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isFakeParent(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isFakeParent = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isFakeChild(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isFakeChild = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_childEntities(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.childEntities = (System.Collections.Generic.List<MarchEntity>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<MarchEntity>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_TargetCoordinateType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                Yoozoo.Gameplay.RTS.Proto.TargetCoordinateType gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.TargetCoordinateType = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isMarchVisibleInLod(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isMarchVisibleInLod = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_defaultForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.defaultForward = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isPveBattleWin(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MarchEntity gen_to_be_invoked = (MarchEntity)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isPveBattleWin = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
		
		
		
		
    }
}
